import org.junit.Test;
import static org.junit.Assert.*;

public class BinaryOperationTest {
    
    // 测试构造方法和基本功能
    @Test
    public void testBinaryOperation() {
        // 测试正常加法（结果在0-100范围内）
        BinaryOperation addOp = new BinaryOperation(10, 5, '+');
        assertEquals("加法左操作数错误", 10, addOp.getLeftOperand());
        assertEquals("加法右操作数错误", 5, addOp.getRightOperand());
        assertEquals("加法运算符错误", '+', addOp.getOperator());
        assertEquals("加法结果错误", 15, addOp.getValue());
        
        // 测试结果超过100的加法（应该被限制为100）
        BinaryOperation maxAddOp = new BinaryOperation(100, 50, '+');
        assertEquals("加法结果限制错误", 100, maxAddOp.getValue());
        
        // 测试正常减法（结果在0-100范围内）
        BinaryOperation subOp = new BinaryOperation(10, 5, '-');
        assertEquals("减法左操作数错误", 10, subOp.getLeftOperand());
        assertEquals("减法右操作数错误", 5, subOp.getRightOperand());
        assertEquals("减法运算符错误", '-', subOp.getOperator());
        assertEquals("减法结果错误", 5, subOp.getValue());
        
        // 测试结果为负数的减法（应该被限制为0）
        BinaryOperation minSubOp = new BinaryOperation(5, 10, '-');
        assertEquals("减法结果限制错误", 0, minSubOp.getValue());
    }
    
    // 测试equals方法
    @Test
    public void testEquals() {
        BinaryOperation op1 = new BinaryOperation(10, 5, '+');
        BinaryOperation op2 = new BinaryOperation(10, 5, '+');
        BinaryOperation op3 = new BinaryOperation(5, 10, '+');
        BinaryOperation op4 = new BinaryOperation(10, 5, '-');
        
        // 自反性测试
        assertTrue("自反性测试失败", op1.equals(op1));
        
        // 相等性测试
        assertTrue("相等性测试失败", op1.equals(op2));
        
        // 不相等性测试
        assertFalse("不相等性测试失败（操作数顺序不同）", op1.equals(op3));
        assertFalse("不相等性测试失败（运算符不同）", op1.equals(op4));
        assertFalse("null比较测试失败", op1.equals(null));
        assertFalse("类型不同比较测试失败", op1.equals("不是BinaryOperation对象"));
    }
    
    // 测试toString方法
    @Test
    public void testToString() {
        BinaryOperation op = new BinaryOperation(10, 5, '+');
        assertEquals("toString格式错误", "10+5=15", op.toString());
        
        BinaryOperation op2 = new BinaryOperation(20, 8, '-');
        assertEquals("toString格式错误", "20-8=12", op2.toString());
    }
    
    // 测试generateAdditionOperation方法
    @Test
    public void testGenerateAdditionOperation() {
        BinaryOperation op = BinaryOperation.generateAdditionOperation();
        
        // 验证运算符正确
        assertEquals("运算符应该是+", '+', op.getOperator());
        
        // 验证操作数范围（0-100）
        int left = op.getLeftOperand();
        int right = op.getRightOperand();
        assertTrue("左操作数应该在0-100范围内", left >= 0 && left <= 100);
        assertTrue("右操作数应该在0-100范围内", right >= 0 && right <= 100);
        
        // 验证和不超过100
        assertTrue("和应该不超过100", left + right <= 100);
        
        // 验证计算结果在0-100范围内
        int result = op.getValue();
        assertTrue("加法结果应该在0-100范围内", result >= 0 && result <= 100);
        
        // 验证计算结果正确（考虑结果限制）
        int expected = Math.min(100, left + right);
        assertEquals("加法计算错误", expected, result);
    }
    
    // 测试generateSubtractOperation方法
    @Test
    public void testGenerateSubtractOperation() {
        BinaryOperation op = BinaryOperation.generateSubtractOperation();
        
        // 验证运算符正确
        assertEquals("运算符应该是-", '-', op.getOperator());
        
        // 验证操作数范围和条件
        int left = op.getLeftOperand();
        int right = op.getRightOperand();
        assertTrue("左操作数应该在0-100范围内", left >= 0 && left <= 100);
        assertTrue("右操作数应该在0-left范围内", right >= 0 && right <= left);
        
        // 验证计算结果在0-100范围内
        int result = op.getValue();
        assertTrue("减法结果应该在0-100范围内", result >= 0 && result <= 100);
        
        // 验证计算结果正确（考虑结果限制）
        int expected = Math.max(0, left - right);
        assertEquals("减法计算错误", expected, result);
    }
    
    // 测试边界情况
    @Test
    public void testBoundaryConditions() {
        // 保持与原测试类似的结构，但减少测试用例数量
        // 测试左操作数为0的情况
        BinaryOperation zeroLeft = new BinaryOperation(0, 5, '+');
        assertEquals("左操作数为0的加法错误", 5, zeroLeft.getValue());
        
        // 测试右操作数为0的情况
        BinaryOperation zeroRight = new BinaryOperation(5, 0, '-');
        assertEquals("右操作数为0的减法错误", 5, zeroRight.getValue());
        
        // 测试结果为0的情况
        BinaryOperation resultZero = new BinaryOperation(5, 5, '-');
        assertEquals("结果为0的减法错误", 0, resultZero.getValue());
        
        // 添加对新功能的测试 - 加法结果限制为100
        BinaryOperation maxAdd = new BinaryOperation(90, 20, '+');
        assertTrue("加法结果应该不超过100", maxAdd.getValue() <= 100);
        
        // 添加对新功能的测试 - 减法结果限制为非负
        BinaryOperation minSub = new BinaryOperation(5, 10, '-');
        assertTrue("减法结果应该不小于0", minSub.getValue() >= 0);
    }
    
    // 测试异常情况
    @Test(expected = IllegalArgumentException.class)
    public void testInvalidOperator() {
        // 测试不支持的运算符应该抛出异常
        new BinaryOperation(10, 5, '*');
    }
}